package com.boot.security.server.utils;

import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Random;
import java.util.SimpleTimeZone;

import org.apache.commons.lang3.StringUtils;



/**
 * 描述：日期处理常用类
 *
 * @author tongbiao
 */

public class DateUtils {
    public static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    public static SimpleDateFormat dateFormat2 = new SimpleDateFormat("yyyy-MM");
    public static SimpleDateFormat dateFormatDB = new SimpleDateFormat("yyyyMMdd");// 数据库使用的日期格式
    public static SimpleDateFormat dataTimeFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    public static final String Y_M_D = "yyyy-MM-dd";
    public static final String Y_M_D_HM = "yyyy-MM-dd HH:mm";
    public static final String Y_M_D_HMS = "yyyy-MM-dd HH:mm:ss";
    public static final String YMD = "yyyyMMdd";
    public static final String YMDHM = "yyyyMMddHHmm";
    public static final String YMDHMS = "yyyyMMddHHmmss";
    public static final String ymd = "yyyy/MM/dd";
    public static final String ymd_HM = "yyyy/MM/dd HH:mm";
    public static final String ymd_HMS = "yyyy/MM/dd HH:mm:ss";

    /**
     * 两时间相减 返回
     * @param startTime
     * @param endTime
     * @return
     */
    public static String getSubTwoTime(String endTime,String startTime){
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        try{

            Date d1 = df.parse(startTime);
            Date d2 = df.parse(endTime);
            long diff = d1.getTime() - d2.getTime();//这样得到的差值是微秒级别
            long days = diff / (1000 * 60 * 60 * 24);

            long hours = (diff-days*(1000 * 60 * 60 * 24))/(1000* 60 * 60);
            long minutes = (diff-days*(1000 * 60 * 60 * 24)-hours*(1000* 60 * 60))/(1000* 60);
//	  System.out.println(""+days+"天"+hours+"小时"+minutes+"分");
            if(hours <0){
                hours = new BigDecimal(hours).abs().intValue();
            }
            if(minutes <0){
                minutes = new BigDecimal(minutes).abs().intValue();
            }
            return ""+days+"-"+hours+"-"+minutes;
        }catch(Exception e){
            e.printStackTrace();
        }
        return "";
    }
    /**
     * 两时间相减 返回
     * @param startTime
     * @param endTime
     * @return
     */
    public static String getSubTwoTimeYY(String endTime,String startTime){
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd");

        try{
            Date d1 = df.parse(startTime);
            Date d2 = df.parse(endTime);
            long diff = d1.getTime() - d2.getTime();//这样得到的差值是微秒级别
            long days = diff / (1000 * 60 * 60 * 24);
            return ""+days;
        }catch(Exception e){
            e.printStackTrace();
        }
        return "";
    }
    /**
     * 两时间相减 返回
     * @param startTime
     * @param endTime
     * @return
     */
    public static String getSubTwoTime1(String endTime,String startTime){
        DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

        try{

            Date d1 = df.parse(startTime);
            Date d2 = df.parse(endTime);
            long diff = d2.getTime() - d1.getTime();//这样得到的差值是微秒级别
            long days = diff / (1000 * 60 * 60 * 24);

            long hours = (diff-days*(1000 * 60 * 60 * 24))/(1000* 60 * 60);
            long minutes = (diff-days*(1000 * 60 * 60 * 24)-hours*(1000* 60 * 60))/(1000* 60);
//	  System.out.println(""+days+"天"+hours+"小时"+minutes+"分");
            if(hours <0){
                hours = new BigDecimal(hours).abs().intValue();
            }
            if(minutes <0){
                minutes = new BigDecimal(minutes).abs().intValue();
            }
            return ""+days+"-"+hours+"-"+minutes;
        }catch(Exception e){
            e.printStackTrace();
        }
        return "";
    }
    /**
     *
     * @param dateTime yyyy-MM-dd HH:mm:ss
     * @return unix 时间
     */
    public static String getUnixTimeStamp(String dateTime){

        Calendar c = Calendar.getInstance();
        try {
            c.setTime(dataTimeFormat.parse(dateTime));
        } catch (ParseException e) {
            e.printStackTrace();
        }

        return (c.getTimeInMillis()/1000)+"";
    }
    /**
     * unix 时间 转换
     * @param timestampString  1252639886
     * @param formats
     * @return
     */
    public static String gerUnixTime2String(String timestampString, String formats){

        if(StringUtils.isBlank(timestampString) || "null".equals(timestampString)){
            return "";
        }
        Long timestamp = Long.parseLong(timestampString)*1000;
        String date = new java.text.SimpleDateFormat(formats).format(new java.util.Date(timestamp));
        return date;
    }
    /**
     *
     * @param  yyyy-MM-dd HH:mm:ss
     * @return unix 时间
     */
    public static String getCurrentUnixTimeStamp(){

        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        return (c.getTimeInMillis()/1000)+"";
    }
    public static String formatDateTime(Date date) {
        return dataTimeFormat.format(date);
    }

    /**
     * 创建一个"yyyy-MM-dd"日期的格式化对象
     * @return "yyyy-MM-dd"日期的格式化对象
     */
    private static SimpleDateFormat newLongYMDFormat() {
        return new SimpleDateFormat("yyyy-MM-dd");
    }

    /**
     * 创建一个"yyyy-MM-dd HH:mm:ss"日期的格式化对象
     * @return "yyyy-MM-dd HH:mm:ss"日期的格式化对象
     */
    private static SimpleDateFormat newLongYMDHMSFormat() {
        return new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    }

    /**
     * "yyyyMMddHHmmss"格式的日期转换为"yyyy-MM-dd HH:mm:ss"格式的日期
     * @param shortYMDHMS "yyyyMMddHHmmss"格式的日期
     * @return "yyyy-MM-dd HH:mm:ss"格式的日期
     * @throws ParseException
     */
    public static String toLongYMDHMS(String shortYMDHMS) throws ParseException {
        return newLongYMDHMSFormat().format(newShortYMDHMSFormat().parse(shortYMDHMS));
    }

    /**
     * 获得"yyyy-MM-dd"格式的当前日期
     * @return 返回"yyyy-MM-dd"格式的当前日期
     */
    public static String getLongYMD() {
        return newLongYMDFormat().format(new Date());
    }
    /**
     * 2015年12月21日
     * @return
     */
    public static String getLongYMDChina() {
        String str = newLongYMDFormat().format(new Date());
        return str.split("-")[0]+"年"+str.split("-")[1]+"月"+str.split("-")[2]+"日";
    }

    /**
     * 创建一个"yyyyMMdd"日期的格式化对象
     * @return "yyyyMMdd"日期的格式化对象
     */
    private static SimpleDateFormat newShortYMDFormat() {
        return new SimpleDateFormat("yyyyMMdd");
    }

    /**
     * 创建一个"yyyyMMddHHmmss"日期的格式化对象
     * @return "yyyyMMddHHmmss"日期的格式化对象
     */
    private static SimpleDateFormat newShortYMDHMSFormat() {
        return new SimpleDateFormat("yyyyMMddHHmmss");
    }
    /**
     * 获得一个时间戳ID
     */
    public static String getTimestampID(){
        return (getShortYMDHMS() + (int)((Math.random()*9+1)* 10000));
    }
    /**
     * 获得"yyyyMMddHHmmss"格式的当前日期
     * @return 返回"yyyyMMddHHmmss"格式的当前时间
     */
    public static String getShortYMDHMS() {
        return newShortYMDHMSFormat().format(new Date());
    }

    /**
     * "yyyyMMdd"格式的日期转换为"yyyy-MM-dd"格式的日期
     * @param shortYMD "yyyyMMdd"格式的日期
     * @return "yyyy-MM-dd"格式的日期
     * @throws ParseException
     */
    public static String toLongYMD(String shortYMD) {
        try {
            return newLongYMDFormat().format(newShortYMDFormat().parse(shortYMD));
        } catch (ParseException e) {
            // Auto-generated catch block

            e.printStackTrace();
            return "";
        }
    }

    /**
     *
     * 功能：生成日期yyyyMMdd
     *
     * @return
     */
    public static String getDbDate() {
        return dateFormatDB.format(new Date());
    }

    /**
     *
     * 功能：把日期yyyy-MM-dd格式转换成yyyyMMDD日期格式
     *
     * @param dateStr
     * @return
     */
    public static String convertClientDateToDbDate(String dateStr) {
        String dbDateStr = null;
        try {
            dbDateStr = dateFormatDB.format(dateFormat.parse(dateStr));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return dbDateStr;
    }

    /**
     *
     * 功能：解析数据库中的日期字符串 格式:yyyy-MM-dd
     *
     * @param dateStr
     * @return
     */
    public static Date parseDate(String dateStr) {
        Date date = null;
        try {
            date = dateFormat.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 将UNIX时间转换成标准时间
     * @param timestampString
     * @return
     */
    public static String getDate(String timestampString)
    {
        Long timestamp = Long.parseLong(timestampString)*1000;
        String date = new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new java.util.Date(timestamp));
        return date;
    }

    /**
     *
     * 功能：格式化日期字符串
     * 例如：2008-8-8  转换为2008-08-08
     *
     * @param dateStr
     * @return
     */
    public static String getDateStrFormat(String dateStr) {
        try {
            Date date = dateFormat.parse(dateStr);
            return dateFormat.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     *
     * 功能：格式化日期字符串
     * 例如：2008-8  转换为2008-08
     *
     * @param dateStr
     * @return
     */
    public static String getDateStrFormat2(String dateStr) {
        try {
            Date date = dateFormat2.parse(dateStr);
            return dateFormat2.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }
    /**
     * 2008-8-8 转 20080808
     * @param dateStr
     * @return
     */
    public static String getDateStrFormatyyyyMMdd(String dateStr) {
        try {
            Date date = dateFormat.parse(dateStr);
            return dateFormatDB.format(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     *
     * 功能：解析数据库中的时间字符串 格式:yyyy-MM-dd HH:mm:ss
     *
     * @param dateTimeStr
     * @return
     */
    public static Date parseDateTime(String dateTimeStr) {
        Date date = null;
        try {
            date = dataTimeFormat.parse(dateTimeStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;
    }

    /**
     * 计算两个日期之间的天数
     *
     * @param startDate
     *          开始时间
     * @param endDate
     *          结束时间
     * @return
     */
    public static int calcDays(String startDate, String endDate) {
        int days = 1;
        try {
            long start = dateFormat.parse(startDate).getTime();
            long end = dateFormat.parse(endDate).getTime();
            days = (int) ((end - start) / (24 * 60 * 60 * 1000));
        } catch (ParseException e) {
            e.printStackTrace();
            return -1;
        }
        return days;
    }

    /**
     * 计算两个日期之间的天数
     *
     * @param startDate
     *          开始时间
     * @param endDate
     *          结束时间
     * @return
     */
    public static int calcDay(String startDate, String endDate) {
        int days = 1;
        try {
            long start = dateFormatDB.parse(startDate).getTime();
            long end = dateFormatDB.parse(endDate).getTime();
            days = (int) ((end - start) / (24 * 60 * 60 * 1000));
        } catch (ParseException e) {
            e.printStackTrace();
            return -1;
        }
        return days;
    }

    /**
     * 功能：指定日期加上指定天数
     *
     * @param date
     *          日期
     * @param day
     *          天数
     * @return 返回相加后的日期
     */
    public static Date addDate(Date date, int day) {
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(getMillis(date) + ((long) day) * 24 * 3600 * 1000);
        return c.getTime();
    }

    /**
     * 功能：指定日期加上指定天数
     *
     * @param date
     *          日期
     * @param minute
     *          分钟
     * @return 返回相加后的日期
     */
    public static Date addMinute(Date date, int minute) {
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(getMillis(date) + ((long) minute) * 60 * 1000);
        return c.getTime();
    }

    /**
     *
     * 功能：添加指定秒杀的时间
     *
     * @param date
     * @param second
     * @return
     */
    public static Date addSecond(Date date, int second) {
        long s = date.getTime();
        s = s + second * 1000;
        return new Date(s);
    }

    /**
     * 功能：指定日期减去指定天数
     *
     * @param date
     * @param day
     * @return
     */
    public static Date diffDate(Date date, int day) {
        Calendar c = Calendar.getInstance();
        c.setTimeInMillis(getMillis(date) - ((long) day) * 24 * 3600 * 1000);
        return c.getTime();
    }

    /**
     *
     * 功能：分钟相差 minute的时间值
     *
     * @param date
     * @param minute
     * @return
     */
    public static Date getDateByMinuteAdd(Date date, int minute) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MINUTE, minute);
        return calendar.getTime();
    }

    /**
     * 功能:两个日期相隔天数
     *
     * @param startDate
     *          开始日期
     * @param endDate
     *          结束日期
     * @return 返回相减后的日期
     */
    public static int diffDate(Date startDate, Date endDate) {
        long endMillis = endDate.getTime();
        long startMillis = startDate.getTime();
        long s = (endMillis - startMillis) / (24 * 3600 * 1000);
        return (int) s;
    }

    /**
     * 功能：传入时间按所需格式返回时间字符串
     *
     * @param date
     *          java.util.Date格式
     * @param format
     *          yyyy-MM-dd HH:mm:ss | yyyy年MM月dd日 HH时mm分ss秒
     * @return
     */
    public static String format(Date date, String format) {
        String result = "";
        try {
            if (date == null) {
                date = new Date();// 如果时间为空,则默认为当前时间
            }
            if (StringUtils.isBlank(format)) {// 默认格式化形式
                format = "yyyy-MM-dd";
            }
            DateFormat df = new SimpleDateFormat(format);
            result = df.format(date);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 功能：传入时间字符串按所需格式返回时间
     *
     * @param dateStr
     *          时间字符串
     * @param format
     *          跟传入dateStr时间的格式必须一样 yyyy-MM-dd HH:mm:ss | yyyy年MM月dd日 HH时mm分ss秒
     * @return
     */
    public static Date format(String dateStr, String format) {
        if (StringUtils.isBlank(dateStr)) {
            return new Date();
        }
        if (StringUtils.isBlank(format)) {
            format = "yyyy-MM-dd";
        }
        Date date = null;
        try {
            DateFormat f = new SimpleDateFormat(format);
            date = f.parse(dateStr);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return date;

    }

    /**
     * 功能：时间字符串格式转换
     *
     * @param dateStr
     *          时间字符串
     * @param format
     *          时间字符串的格式
     * @param toFormat
     *          格式为的格式
     * @return
     */
    public static String format(String dateStr, String format, String toFormat) {
        return format(format(dateStr, format), toFormat);
    }

    /**
     * 功能：格式化rss的时间
     * 输入:
     * @param date
     * @return
     */
    public static String formatRssDate(Date date) {
        if (date == null) {
            date = new Date();// 如果时间为空,则默认为当前时间
        }
        SimpleDateFormat sdf = new SimpleDateFormat("EEE, dd MMM yyyy HH:mm:ss z", Locale.US);
        SimpleTimeZone zone = new SimpleTimeZone(8, "GMT");
        sdf.setTimeZone(zone);
        return sdf.format(date);
    }

    /**
     * 功能：返回年
     *
     * @param date
     * @return
     */
    public static int getYear(Date date) {
        if (date == null) {
            date = new Date();
        }
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.YEAR);

    }

    /**
     * 功能：返回月
     *
     * @param date
     * @return
     */
    public static int getMonth(Date date) {
        if (date == null) {
            date = new Date();
        }
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.MONTH) + 1;
    }

    /**
     * 功能：返回日
     *
     * @param date
     * @return
     */
    public static int getDay(Date date) {
        if (date == null) {
            date = new Date();
        }
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.DAY_OF_MONTH);
    }

    /**
     * 功能：返回小时
     *
     * @param date
     * @return
     */
    public static int getHour(Date date) {
        if (date == null) {
            date = new Date();
        }
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.HOUR_OF_DAY);
    }

    /**
     * 功能：返回分
     *
     * @param date
     * @return
     */
    public static int getMinute(Date date) {
        if (date == null) {
            date = new Date();
        }
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.MINUTE);
    }

    /**
     * 功能：返回星期 1：星期一，2:星期二 ... 6:星期六 7:星期日
     *
     * @param date
     * @return
     */
    public static int getChinaWeek(Date date) {
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        int week = c.get(Calendar.DAY_OF_WEEK) - 1;
        if (week == 0) {
            return 7;
        } else {
            return week;
        }
    }

    /**
     * 功能：返回秒
     *
     * @param date
     * @return
     */
    public static int getSecond2(Date date) {
        if (date == null) {
            date = new Date();
        }
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.get(Calendar.SECOND);
    }

    /**
     * 功能：返回毫秒
     *
     * @param date
     * @return
     */
    public static long getMillis(Date date) {
        if (date == null) {
            date = new Date();
        }
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        return c.getTimeInMillis();
    }

    /**
     * 功能：获取当前月的第一天日期
     *
     * @return
     */
    public static Date getMonFirstDay() {
        Date date = new Date();
        Calendar c = Calendar.getInstance();
        c.set(getYear(date), getMonth(date) - 1, 1);
        return c.getTime();
    }

    /**
     * 功能：获取当前月的最后一天日期
     *
     * @return
     */
    public static Date getMonLastDay() {
        Date date = new Date();
        Calendar c = Calendar.getInstance();
        c.set(getYear(date), getMonth(date), 1);
        c.setTimeInMillis(c.getTimeInMillis() - (24 * 3600 * 1000));
        return c.getTime();
    }
    /**
     * 功能：获取上个月的最后一天日期
     *
     * @return
     */
    public static Date getMonUpDay() {
        Date date = new Date();
        Calendar c = Calendar.getInstance();
        c.set(getYear(date), getMonth(date)-1, 1);
        c.setTimeInMillis(c.getTimeInMillis() - (24 * 3600 * 1000));
        return c.getTime();
    }

    /** 获得本月的第一天的日期 */
    public static String getCurrMonthFirstDay() {
        Calendar cal = Calendar.getInstance();
        String s = (getYear(cal)) + "-" + (getMonth(cal)) + "-01";
        return s;
    }
    /** 获得当前月份2015-11 */
    public static String getCurrMonth() {
        Calendar cal = Calendar.getInstance();
        String s = (getYear(cal)) + "-" + (getMonth(cal));
        return getDateStrFormat2(s);
    }

    /** 获得本月的最后一天的日期 */
    public static String getCurrMonthLastDay() {
        Calendar cal = Calendar.getInstance();
        String s = (getYear(cal)) + "-" + (getMonth(cal)) + "-" + getDays(cal);
        return s;
    }

    /** 获得给定日期当月的天数 */
    public static int getDays(Calendar cal) {
        return cal.getActualMaximum(Calendar.DAY_OF_MONTH);
    }

    /** 获得给定日历的年 */
    public static int getYear(Calendar cal) {
        return cal.get(Calendar.YEAR);
    }

    /** 获得给定日历的月 */
    public static int getMonth(Calendar cal) {
        return (cal.get(Calendar.MONTH) + 1);
    }

    /** 获得给定日期字符串对应的年 */
    public static int getYear(String date_str, String type) {
        return (convertStrToCal(date_str, type).get(Calendar.YEAR));
    }

    /** 日期转日历* */
    public static Calendar convertDateToCal(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal;
    }

    /** 字符转换日历(动态格式转换) */
    public static Calendar convertStrToCal(String date_str, String type) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(convertStrToDate(date_str, type));
        return cal;
    }

    /** 字符转换日期(动态格式转换) */
    public static Date convertStrToDate(String date_str, String type) {
        SimpleDateFormat dateformat = new SimpleDateFormat(type);
        try {
            return dateformat.parse(date_str);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 功能：获取当前日期 格式:2008-02-02 23:11:10
     *
     * @return
     */
    public static String getCurrentDateTime() {
        Date date = new Date();
        return dataTimeFormat.format(date);
    }

    /**
     * 功能：获取当前日期 格式:20101010
     *
     * @return
     */
    public static String getCurrentDate() {
        Date date = new Date();
        return dateFormat.format(date);
    }


    /**
     * 创建一个"yyyyMM"日期的格式化对象
     * @return "yyyyMM"日期的格式化对象
     */
    private static SimpleDateFormat newShortYMFormat() {
        return new SimpleDateFormat("yyyyMM");
    }

    /**
     * 获得距离输入月份的diffMonth月的日期
     * @param month "yyyyMM"格式的日期
     * @param diffMonth 相差的月数
     * @return "yyyyMM"格式的日期
     * @throws ParseException
     */
    public static String getShortYMDiffMonth(String month, int diffMonth) {
        SimpleDateFormat sdf = newShortYMFormat();
        try {
            sdf.parse(month);
        } catch (ParseException e) {
            // Auto-generated catch block
            e.printStackTrace();
        }
        Calendar c = sdf.getCalendar();
        c.add(Calendar.MONTH, diffMonth);
        return sdf.format(c.getTime());
    }

    /**
     * 获得距离给定日期diffDay天的日期
     * @param shortYMD "yyyyMMdd"格式的日期
     * @param diffDay 相差的天数
     * @return "yyyyMMdd"格式的日期
     * @throws ParseException
     */
    public static String getShortYMDDiffDay(String shortYMD, int diffDay) {
        SimpleDateFormat sdf = newShortYMDFormat();
        try {
            sdf.parse(shortYMD);
        } catch (ParseException e) {
            // Auto-generated catch block
            e.printStackTrace();
        }
        Calendar c = sdf.getCalendar();
        c.add(Calendar.DATE, diffDay);
        return sdf.format(c.getTime());
    }
    /**
     * 当前时间加 减days
     * @param diffDay
     * @param diffDay
     * @return
     */
    public static String getAddDay(int diffDay) {
        SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm");
        Calendar c = Calendar.getInstance();
        c.add(Calendar.DAY_OF_MONTH, diffDay);
        return sf.format(c.getTime());
    }

    /**
     * 获取某月份的最后一天
     * @param shortYM 月份
     * @return 输入月份的最后一天
     * @throws Exception
     */
    public static String getEndDayOfMonth(String shortYM) {
        String month = "";
        try {
            month = DateUtils.getShortYMDiffMonth(shortYM, 1);
        } catch (Exception e) {
            // Auto-generated catch block
            e.printStackTrace();
        }
        return DateUtils.getShortYMDDiffDay(month + "01", -1);
    }

    /**
     * 获得"yyyyMMdd"格式的当前日期
     * @return 返回"yyyyMMdd"格式的当前日期
     */
    public static String getShortYMD() {
        return newShortYMDFormat().format(new Date());
    }

    /**
     * 获得两个日期之间的所有日期列表（包括起始日期和结束日期）
     * @param startShortYMD "yyyyMMdd"格式的起始日期
     * @param endShortYMD "yyyyMMdd"格式的结束日期
     * @return "yyyyMMdd"格式的日期列表
     * @throws ParseException
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static List getShortYMDList(String startShortYMD, String endShortYMD) throws ParseException {
        SimpleDateFormat startDateFormat = newShortYMDFormat();
        startDateFormat.parse(startShortYMD);
        Calendar startCal = startDateFormat.getCalendar();

        SimpleDateFormat endDateFormat = newShortYMDFormat();
        endDateFormat.parse(endShortYMD);
        Calendar endCal = endDateFormat.getCalendar();

        List dateList = new ArrayList();
        while (startCal.before(endCal)) {
            dateList.add(startDateFormat.format(startCal.getTime()));
            startCal.add(Calendar.DATE, 1);
        }

        if (startCal.getTimeInMillis() == endCal.getTimeInMillis()) {
            dateList.add(startDateFormat.format(endCal.getTime()));
        }

        return dateList;
    }

    /**
     * 获得两个日期之间的所有日期列表（包括起始日期和结束日期）
     * @param startShortYM "yyyyMM"格式的起始日期
     * @param endShortYM "yyyyMM"格式的结束日期
     * @return "yyyyMM"格式的日期列表
     * @throws ParseException
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public static List getShortYMList(String startShortYM, String endShortYM) throws ParseException {
        SimpleDateFormat startDateFormat = newShortYMFormat();
        startDateFormat.parse(startShortYM);
        Calendar startCal = startDateFormat.getCalendar();

        SimpleDateFormat endDateFormat = newShortYMFormat();
        endDateFormat.parse(endShortYM);
        Calendar endCal = endDateFormat.getCalendar();

        List dateList = new ArrayList();
        while (startCal.before(endCal)) {
            dateList.add(startDateFormat.format(startCal.getTime()));
            startCal.add(Calendar.MONTH, 1);
        }

        if (startCal.getTimeInMillis() == endCal.getTimeInMillis()) {
            dateList.add(startDateFormat.format(endCal.getTime()));
        }

        return dateList;
    }

    /**
     * 验证输入的日期是否合法
     * @param expDate
     * @return
     */
    public static boolean checkExpDate(String expDate) {
        int year = Integer.parseInt(expDate.substring(0, 4));
        int month = Integer.parseInt(expDate.substring(4, 6));
        int day = Integer.parseInt(expDate.substring(6, 8));
        if (month > 12 || month < 1) {
            return false;
        }

        int[] monthLengths = new int[] { 0, 31, -1, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };

        if (isLeapYear(year)) {
            monthLengths[2] = 29;
        } else {
            monthLengths[2] = 28;
        }

        int monthLength = monthLengths[month];
        if (day < 1 || day > monthLength) {
            return false;
        }
        return true;
    }

    /**
     * 是否是闰年
     * */
    private static boolean isLeapYear(int year) {
        return ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0);
    }

    /**
     *
     * 方法用途: 结束时间（end）与start时间进行比较<br>
     * 实现步骤: 如果相等返回0，如果end大于start返回1，如果end小于start返回-1<br>
     * @param start
     * @param end
     * @return
     * @throws Exception
     */
    public static int compareEndAndStart(String start, String end) throws Exception {
        long s = 0;
        if (8 == start.length()) {
            s = dateFormatDB.parse(start).getTime();
        } else if (10 == start.length()) {
            s = dateFormat.parse(start).getTime();
        } else {
            s = dataTimeFormat.parse(start).getTime();
        }
        long e = 0;
        if (8 == end.length()) {
            e = dateFormatDB.parse(end).getTime();
        } else if (10 == end.length()) {
            e = dateFormat.parse(end).getTime();
        } else {
            e = dataTimeFormat.parse(end).getTime();
        }
        if (e > s) {
            return 1;
        } else if (e < s) {
            return -1;
        }
        return 0;
    }

    /**
     * 根据传过来的字符串型的date，转换成对应的日期
     * @param date
     * @return
     */
    public static Date str2Date(String date) {
        Date ret = null;
        if (date.length() == 10) {
            try {
                ret = new SimpleDateFormat("yyyy-MM-dd").parse(date);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        if (date.length() == 16) {
            try {
                ret = new SimpleDateFormat("yyyy-MM-dd HH:mm").parse(date);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        if (date.length() == 19) {
            try {
                ret = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(date);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        if (date.length() == 13) {
            try {
                ret = new SimpleDateFormat("yyyy-MM-dd HH").parse(date);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        if (date.length() == 7) {
            try {
                ret = new SimpleDateFormat("yyyy-MM").parse(date);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return ret;
    }

    /**
     * 获取8位随机数
     * @return
     */
    public static String getRandomNum(){
        Random r=new Random();
        int a = r.nextInt(99999999);
        String	cardNum = ""+a;
        int length = cardNum.length();
        if(length<8){
            for(int j=0; j<(8-length); j++){
                cardNum = "0"+cardNum;
            }
        }
        return cardNum;
    }

    /**
     * 智能转换日期
     *
     * @param text
     * @return
     */
    public static Date smartFormat(String text) {
        Date date = null;
        try {
            if (text == null || text.length() == 0) {
                date = null;
            } else if (text.length() == 10) {
                date = formatStringToDate(text, Y_M_D);
            } else if (text.length() == 13) {
                date = new Date(Long.parseLong(text));
            } else if (text.length() == 14) {
                date = formatStringToDate(text, YMDHMS);
            } else if (text.length() == 16) {
                date = formatStringToDate(text, Y_M_D_HM);
            } else if (text.length() == 19) {
                date = formatStringToDate(text, Y_M_D_HMS);
            } else {
                throw new IllegalArgumentException("日期长度不符合要求!");
            }
        } catch (Exception e) {
            throw new IllegalArgumentException("日期转换失败!");
        }
        return date;
    }

    /**
     * 把字符串格式化成日期
     *
     * @param argDateStr
     * @param argFormat
     * @return
     */
    public static Date formatStringToDate(String argDateStr, String argFormat) throws Exception {
        if (argDateStr == null || argDateStr.trim().length() < 1) {
            throw new Exception("参数[日期]不能为空!");
        }
        String strFormat = argFormat;
        if (StringUtils.isEmpty(strFormat)) {
            strFormat = Y_M_D;
            if (argDateStr.length() > 16) {
                strFormat = Y_M_D_HMS;
            } else if (argDateStr.length() > 10) {
                strFormat = Y_M_D_HM;
            }
        }
        SimpleDateFormat sdfFormat = new SimpleDateFormat(strFormat);
        // 严格模式
        sdfFormat.setLenient(false);
        try {
            return sdfFormat.parse(argDateStr);
        } catch (ParseException e) {
            throw new Exception(e);
        }
    }
    public static String getSSTimeStamp(){
        Date d = new Date();
        SimpleDateFormat sdf=new SimpleDateFormat("HH:mm:ss:SS");
        String strddd = sdf.format(d);
        return strddd;
    }

    /**
     * 获取当前日期是星期几<br>
     *
     * @return 当前日期是星期几
     */
    public static String getWeekOfDate() {
        String[] weekDays = {"7", "1", "2", "3", "4", "5", "6"};
//        String[] weekDays = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        Calendar cal = Calendar.getInstance();
//        cal.setTime(dt);
        int w = cal.get(Calendar.DAY_OF_WEEK) - 1;
        if (w < 0)
            w = 0;
        return weekDays[w];
    }


//		public static void main(String[] args) throws Exception {
//
//			System.out.println(getSSTimeStamp());
//		}

    /**
     * 功能：返回上旬/中旬/下旬
     * 1 ：上旬  2： 中旬  3： 下旬
     * @param date
     * @return
     */
    public static int getEarlyMidLate(Date date) {
        int day=getDay(date);
        int earlyMidLate=0;
        if(1<=day && day<= 10){
            earlyMidLate=1;
        }
        if(11<=day && day<=20){
            earlyMidLate=2;
        }
        if(20<day){
            earlyMidLate=3;
        }
        return earlyMidLate;
    }

    /**
     * 将日期转换成Julian日期，即为哪一年的第几天
     * @param date
     * @author gongz
     * @return
     */
    public static int dateToJulian(Date date){
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        int year = calendar.get(Calendar.YEAR)%100;
        int dayOfYear = calendar.get(Calendar.DAY_OF_YEAR);
        return year*1000 + dayOfYear;
    }
    /**
     * 将Julian日期转化为date，即为哪一年的第几天
     * @param date
     * @return
     */
    public static Date JulianToDate(int date){
        int year = (date/1000)+2000;
        int dayOfYear = date %1000;
        Calendar calendar =Calendar.getInstance();
        calendar.set(Calendar.YEAR, year);
        calendar.set(Calendar.DAY_OF_YEAR, dayOfYear);
        return calendar.getTime();
    }

    /**
     * 返回当前月份的第一天
     * @author gongz
     * @return
     */
    public static Date currentMonthFirstDay(){
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.MONTH, 0);
        calendar.set(Calendar.DAY_OF_MONTH, 1); //设置为1号，当前日期既为本月第一天
        return calendar.getTime();
    }

    /**
     * 返回当前月份的最后一天
     * @author gongz
     * @return
     */
    public static Date currentMonthLastDay(){
        Calendar calendar = Calendar.getInstance();
        calendar.add(Calendar.MONTH, 0);
        calendar.set(Calendar.DAY_OF_MONTH, calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        return calendar.getTime();
    }
    public static int statisSubDay(Date endDate,Date startDate){

        Calendar fromCalendar = Calendar.getInstance();
        fromCalendar.setTime(startDate);
        fromCalendar.set(Calendar.HOUR_OF_DAY, 0);
        fromCalendar.set(Calendar.MINUTE, 0);
        fromCalendar.set(Calendar.SECOND, 0);
        fromCalendar.set(Calendar.MILLISECOND, 0);

        Calendar toCalendar = Calendar.getInstance();
        toCalendar.setTime(endDate);
        toCalendar.set(Calendar.HOUR_OF_DAY, 0);
        toCalendar.set(Calendar.MINUTE, 0);
        toCalendar.set(Calendar.SECOND, 0);
        toCalendar.set(Calendar.MILLISECOND, 0);
        Long tempString = (toCalendar.getTime().getTime() - fromCalendar.getTime().getTime()) / (1000 * 60 * 60 * 24);
        return Integer.valueOf(tempString.toString());
    }

    /**
     * 时间减去 几小时 返回时间
     * @param strDate
     * @param a
     * @return
     */
    public static String getSubTwoDate(String strDate,int a){
        try{
            SimpleDateFormat dft=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Calendar   dar=Calendar.getInstance();
            dar.setTime(dft.parse(strDate));
            dar.add(java.util.Calendar.HOUR_OF_DAY, -a);
            return dft.format(dar.getTime());
        }catch(Exception e){
            e.printStackTrace();
        }
        return "";
    }

    /**
     * 功能：判断两个时间是否相等 精确到分
     *
     * @return
     */
    public static boolean getCurrentDate(String strDate,Date date) {
        SimpleDateFormat dft=new SimpleDateFormat("yyyy-MM-dd HH:mm");
        Calendar   dar=Calendar.getInstance();
        try {
            dar.setTime(dft.parse(strDate));
        } catch (ParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return dft.format(dar.getTime()).equals(dft.format(date));
    }
    public static Date addDate1(Date d,long day) throws ParseException {

        long time = d.getTime();
        day = day*24*60*60*1000;
        time+=day;
        return new Date(time);

    }
    public static Date getLastMonthDay(){
//			SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        Calendar calendar = Calendar.getInstance();
        int month = calendar.get(Calendar.MONTH);
        calendar.set(Calendar.MONTH, month-1);
        calendar.set(Calendar.DAY_OF_MONTH,calendar.getActualMaximum(Calendar.DAY_OF_MONTH));
        Date strDateTo = calendar.getTime();
        return strDateTo;
    }
    public static void main(String[] args) {
//	    	getSubTwoTime("2016-04-13","2016-04-15");
//	    	SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        System.out.println(getSubTwoTimeYY("2016-04-14","2016-04-21"));
    }

}
